home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / game / shoot / ADoom_src_1_2.lha / ADoom_src / r_things.c < prev    next >
C/C++ Source or Header  |  1998-03-01  |  22KB  |  1,039 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Refresh of things, i.e. objects represented by sprites.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: r_things.c,v 1.5 1997/02/03 16:47:56 b1 Exp $";
  27.  
  28.  
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31.  
  32.  
  33. #include "doomdef.h"
  34. #include "m_swap.h"
  35.  
  36. #include "i_system.h"
  37. #include "z_zone.h"
  38. #include "w_wad.h"
  39.  
  40. #include "r_local.h"
  41.  
  42. #include "doomstat.h"
  43.  
  44.  
  45.  
  46. #define MINZ                (FRACUNIT*4)
  47. //#define BASEYCENTER            100
  48. #define BASEYCENTER ((weirdaspect==1)?100:75)
  49.  
  50. //void R_DrawColumn (void);
  51. //void R_DrawFuzzColumn (void);
  52.  
  53.  
  54.  
  55. typedef struct
  56. {
  57.     int        x1;
  58.     int        x2;
  59.     
  60.     int        column;
  61.     int        topclip;
  62.     int        bottomclip;
  63.  
  64. } maskdraw_t;
  65.  
  66.  
  67.  
  68. //
  69. // Sprite rotation 0 is facing the viewer,
  70. //  rotation 1 is one angle turn CLOCKWISE around the axis.
  71. // This is not the same as the angle,
  72. //  which increases counter clockwise (protractor).
  73. // There was a lot of stuff grabbed wrong, so I changed it...
  74. //
  75. fixed_t        pspritescale;
  76. fixed_t        pspriteiscale;
  77. //fixed_t        pspritescale2;
  78. fixed_t        pspriteiscale2;
  79.  
  80. lighttable_t**    spritelights;
  81.  
  82. // constant arrays
  83. //  used for psprite clipping and initializing clipping
  84. //short        negonearray[SCREENWIDTH];
  85. //short        screenheightarray[SCREENWIDTH];
  86. short        *negonearray;
  87. short        *screenheightarray;
  88.  
  89.  
  90. //
  91. // INITIALIZATION FUNCTIONS
  92. //
  93.  
  94. // variables used to look up
  95. //  and range check thing_t sprites patches
  96. spritedef_t*    sprites;
  97. int        numsprites;
  98.  
  99. FAR spriteframe_t    sprtemp[29];
  100. int        maxframe;
  101. char*        spritename;
  102.  
  103.  
  104.  
  105.  
  106. //
  107. // R_InstallSpriteLump
  108. // Local function for R_InitSprites.
  109. //
  110. void
  111. R_InstallSpriteLump
  112. ( int        lump,
  113.   unsigned    frame,
  114.   unsigned    rotation,
  115.   boolean    flipped )
  116. {
  117.     int        r;
  118.     
  119.     if (frame >= 29 || rotation > 8)
  120.     I_Error("R_InstallSpriteLump: "
  121.         "Bad frame characters in lump %i", lump);
  122.     
  123.     if ((int)frame > maxframe)
  124.     maxframe = frame;
  125.         
  126.     if (rotation == 0)
  127.     {
  128.     // the lump should be used for all rotations
  129.     if (sprtemp[frame].rotate == false)
  130.         I_Error ("R_InitSprites: Sprite %s frame %c has "
  131.              "multip rot=0 lump", spritename, 'A'+frame);
  132.  
  133.     if (sprtemp[frame].rotate == true)
  134.         I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  135.              "and a rot=0 lump", spritename, 'A'+frame);
  136.             
  137.     sprtemp[frame].rotate = false;
  138.     for (r=0 ; r<8 ; r++)
  139.     {
  140.         sprtemp[frame].lump[r] = lump - firstspritelump;
  141.         sprtemp[frame].flip[r] = (byte)flipped;
  142.     }
  143.     return;
  144.     }
  145.     
  146.     // the lump is only used for one rotation
  147.     if (sprtemp[frame].rotate == false)
  148.     I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  149.          "and a rot=0 lump", spritename, 'A'+frame);
  150.         
  151.     sprtemp[frame].rotate = true;
  152.  
  153.     // make 0 based
  154.     rotation--;        
  155.     if (sprtemp[frame].lump[rotation] != -1)
  156.     I_Error ("R_InitSprites: Sprite %s : %c : %c "
  157.          "has two lumps mapped to it",
  158.          spritename, 'A'+frame, '1'+rotation);
  159.         
  160.     sprtemp[frame].lump[rotation] = lump - firstspritelump;
  161.     sprtemp[frame].flip[rotation] = (byte)flipped;
  162. }
  163.  
  164.  
  165.  
  166.  
  167. //
  168. // R_InitSpriteDefs
  169. // Pass a null terminated list of sprite names
  170. //  (4 chars exactly) to be used.
  171. // Builds the sprite rotation matrixes to account
  172. //  for horizontally flipped sprites.
  173. // Will report an error if the lumps are inconsistant. 
  174. // Only called at startup.
  175. //
  176. // Sprite lump names are 4 characters for the actor,
  177. //  a letter for the frame, and a number for the rotation.
  178. // A sprite that is flippable will have an additional
  179. //  letter/number appended.
  180. // The rotation character can be 0 to signify no rotations.
  181. //
  182. void R_InitSpriteDefs (char** namelist) 
  183. { 
  184.     char**    check;
  185.     int        i;
  186.     int        l;
  187.     int        intname;
  188.     int        frame;
  189.     int        rotation;
  190.     int        start;
  191.     int        end;
  192.     int        patched;
  193.         
  194.     // count the number of sprite names
  195.     check = namelist;
  196.     while (*check != NULL)
  197.     check++;
  198.  
  199.     numsprites = check-namelist;
  200.     
  201.     if (!numsprites)
  202.     return;
  203.         
  204.     sprites = Z_Malloc(numsprites *sizeof(*sprites), PU_STATIC, NULL);
  205.     
  206.     start = firstspritelump-1;
  207.     end = lastspritelump+1;
  208.     
  209.     // scan all the lump names for each of the names,
  210.     //  noting the highest frame letter.
  211.     // Just compare 4 characters as ints
  212.     for (i=0 ; i<numsprites ; i++)
  213.     {
  214.     spritename = namelist[i];
  215.     memset (sprtemp,-1, sizeof(sprtemp));
  216.         
  217.     maxframe = -1;
  218.     intname = *(int *)namelist[i];
  219.     
  220.     // scan the lumps,
  221.     //  filling in the frames for whatever is found
  222.     for (l=start+1 ; l<end ; l++)
  223.     {
  224.         if (*(int *)lumpinfo[l].name == intname)
  225.         {
  226.         frame = lumpinfo[l].name[4] - 'A';
  227.         rotation = lumpinfo[l].name[5] - '0';
  228.  
  229.         if (modifiedgame)
  230.             patched = W_GetNumForName (lumpinfo[l].name);
  231.         else
  232.             patched = l;
  233.  
  234.         R_InstallSpriteLump (patched, frame, rotation, false);
  235.  
  236.         if (lumpinfo[l].name[6])
  237.         {
  238.             frame = lumpinfo[l].name[6] - 'A';
  239.             rotation = lumpinfo[l].name[7] - '0';
  240.             R_InstallSpriteLump (l, frame, rotation, true);
  241.         }
  242.         }
  243.     }
  244.     
  245.     // check the frames that were found for completeness
  246.     if (maxframe == -1)
  247.     {
  248.         sprites[i].numframes = 0;
  249.         continue;
  250.     }
  251.         
  252.     maxframe++;
  253.     
  254.     for (frame = 0 ; frame < maxframe ; frame++)
  255.     {
  256.         switch ((int)sprtemp[frame].rotate)
  257.         {
  258.           case -1:
  259.         // no rotations were found for that frame at all
  260.         I_Error ("R_InitSprites: No patches found "
  261.              "for %s frame %c", namelist[i], frame+'A');
  262.         break;
  263.         
  264.           case 0:
  265.         // only the first rotation is needed
  266.         break;
  267.             
  268.           case 1:
  269.         // must have all 8 frames
  270.         for (rotation=0 ; rotation<8 ; rotation++)
  271.             if (sprtemp[frame].lump[rotation] == -1)
  272.             I_Error ("R_InitSprites: Sprite %s frame %c "
  273.                  "is missing rotations",
  274.                  namelist[i], frame+'A');
  275.         break;
  276.         }
  277.     }
  278.     
  279.     // allocate space for the frames present and copy sprtemp to it
  280.     sprites[i].numframes = maxframe;
  281.     sprites[i].spriteframes = 
  282.         Z_Malloc (maxframe * sizeof(spriteframe_t), PU_STATIC, NULL);
  283.     memcpy (sprites[i].spriteframes, sprtemp, maxframe*sizeof(spriteframe_t));
  284.     }
  285.  
  286. }
  287.  
  288.  
  289.  
  290.  
  291. //
  292. // GAME FUNCTIONS
  293. //
  294. FAR vissprite_t    vissprites[MAXVISSPRITES];
  295. vissprite_t*    vissprite_p;
  296. int        newvissprite;
  297.  
  298.  
  299.  
  300. //
  301. // R_InitSprites
  302. // Called at program start.
  303. //
  304. void R_InitSprites (char** namelist)
  305. {
  306.     int        i;
  307.     
  308.     for (i=0 ; i<SCREENWIDTH ; i++)
  309.     {
  310.     negonearray[i] = -1;
  311.     }
  312.     
  313.     R_InitSpriteDefs (namelist);
  314. }
  315.  
  316.  
  317.  
  318. #ifndef AMIGA
  319. //
  320. // R_ClearSprites
  321. // Called at frame start.
  322. //
  323. void R_ClearSprites (void)
  324. {
  325.     vissprite_p = vissprites;
  326. }
  327. #endif
  328.  
  329.  
  330. #ifdef AMIGA
  331. extern vissprite_t* R_NewVisSprite (void);
  332. #else
  333. //
  334. // R_NewVisSprite
  335. //
  336. vissprite_t    overflowsprite;
  337.  
  338. vissprite_t* R_NewVisSprite (void)
  339. {
  340.     if (vissprite_p == &vissprites[MAXVISSPRITES])
  341.     return &overflowsprite;
  342.     
  343.     vissprite_p++;
  344.     return vissprite_p-1;
  345. }
  346. #endif
  347.  
  348.  
  349.  
  350. //
  351. // R_DrawMaskedColumn
  352. // Used for sprites and masked mid textures.
  353. // Masked means: partly transparent, i.e. stored
  354. //  in posts/runs of opaque pixels.
  355. //
  356. short*        mfloorclip;
  357. short*        mceilingclip;
  358.  
  359. fixed_t        spryscale;
  360. fixed_t        sprtopscreen;
  361.  
  362. #ifndef AMIGA
  363. void R_DrawMaskedColumn (column_t* column)
  364. {
  365.     int        topscreen;
  366.     int     bottomscreen;
  367.     fixed_t    basetexturemid;
  368.     
  369.     basetexturemid = dc_texturemid;
  370.     
  371.     for ( ; column->topdelta != 0xff ; ) 
  372.     {
  373.     // calculate unclipped screen coordinates
  374.     //  for post
  375.     topscreen = sprtopscreen + spryscale*column->topdelta;
  376.     bottomscreen = topscreen + spryscale*column->length;
  377.  
  378.     dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
  379.     dc_yh = (bottomscreen-1)>>FRACBITS;
  380.         
  381.     if (dc_yh >= mfloorclip[dc_x])
  382.         dc_yh = mfloorclip[dc_x]-1;
  383.     if (dc_yl <= mceilingclip[dc_x])
  384.         dc_yl = mceilingclip[dc_x]+1;
  385.  
  386.     if (dc_yl <= dc_yh)
  387.     {
  388.         dc_source = (byte *)column + 3;
  389.         dc_texturemid = basetexturemid - (column->topdelta<<FRACBITS);
  390.         // dc_source = (byte *)column + 3 - column->topdelta;
  391.  
  392.         // Drawn by either R_DrawColumn
  393.         //  or (SHADOW) R_DrawFuzzColumn.
  394.         colfunc ();    
  395.     }
  396.     column = (column_t *)(  (byte *)column + column->length + 4);
  397.     }
  398.     
  399.     dc_texturemid = basetexturemid;
  400. }
  401. #endif
  402.  
  403.  
  404.  
  405. #ifdef AMIGA
  406. extern void R_DrawVisSprite (vissprite_t *vis);
  407. #else
  408. //
  409. // R_DrawVisSprite
  410. //  mfloorclip and mceilingclip should also be set.
  411. //
  412. void
  413. R_DrawVisSprite
  414. ( vissprite_t*        vis,
  415.   int            x1,
  416.   int            x2 )
  417. {
  418.     column_t*        column;
  419.     int            texturecolumn;
  420.     fixed_t        frac;
  421.     patch_t*        patch;
  422.     
  423. //#ifdef AMIGA
  424. //    int            type = TYPE_NORMAL;
  425. //#endif
  426.  
  427.     
  428.     patch = W_CacheLumpNum (vis->patch+firstspritelump, PU_CACHE);
  429.  
  430.     dc_colormap = vis->colormap;
  431.     
  432.     if (!dc_colormap)
  433.     {
  434. //#ifndef AMIGA
  435.     // NULL colormap = shadow draw
  436.     colfunc = fuzzcolfunc;
  437. //#else
  438. //        type = TYPE_FUZZ;
  439. //#endif
  440.     }
  441.     else if (vis->mobjflags & MF_TRANSLATION)
  442.     {
  443. //#ifndef AMIGA
  444.     colfunc = transcolfunc;
  445. //#else
  446. //        type = TYPE_TRANSL;
  447. //#endif
  448.     dc_translation = translationtables - 256 +
  449.         ( (vis->mobjflags & MF_TRANSLATION) >> (MF_TRANSSHIFT-8) );
  450.     }
  451.     
  452.     dc_iscale = iabs(vis->xiscale)>>detailshift;
  453.     dc_texturemid = vis->texturemid;
  454.     frac = vis->startfrac;
  455.     spryscale = vis->scale;
  456.     sprtopscreen = centeryfrac - FixedMul(dc_texturemid,spryscale);
  457.     
  458.     for (dc_x=vis->x1 ; dc_x<=vis->x2 ; dc_x++, frac += vis->xiscale)
  459.     {
  460.     texturecolumn = frac>>FRACBITS;
  461. #ifdef RANGECHECK
  462.     if (texturecolumn < 0 || texturecolumn >= SWAPSHORT(patch->width))
  463.         I_Error ("R_DrawSpriteRange: bad texturecolumn");
  464. #endif
  465.     column = (column_t *) ((byte *)patch +
  466.                    SWAPLONG(patch->columnofs[texturecolumn]));
  467.  
  468. //#ifndef AMIGA
  469.      R_DrawMaskedColumn (column);
  470. //#else
  471. //    R_DrawMaskedColumnAmi (column, type);
  472. //#endif
  473.     }
  474.  
  475.     colfunc = basecolfunc;
  476. }
  477. #endif
  478.  
  479.  
  480.  
  481. //
  482. // R_ProjectSprite
  483. // Generates a vissprite for a thing
  484. //  if it might be visible.
  485. //
  486. void R_ProjectSprite (mobj_t* thing)
  487. {
  488.     fixed_t        tr_x;
  489.     fixed_t        tr_y;
  490.     
  491.     fixed_t        gxt;
  492.     fixed_t        gyt;
  493.     
  494.     fixed_t        tx;
  495.     fixed_t        tz;
  496.  
  497.     fixed_t        xscale;
  498.     
  499.     int            x1;
  500.     int            x2;
  501.  
  502.     spritedef_t*    sprdef;
  503.     spriteframe_t*    sprframe;
  504.     int            lump;
  505.     
  506.     unsigned        rot;
  507.     boolean        flip;
  508.     
  509.     int            index;
  510.  
  511.     vissprite_t*    vis;
  512.     
  513.     angle_t        ang;
  514.     fixed_t        iscale;
  515.     
  516.     // transform the origin point
  517.     tr_x = thing->x - viewx;
  518.     tr_y = thing->y - viewy;
  519.     
  520.     gxt = FixedMul(tr_x,viewcos); 
  521.     gyt = -FixedMul(tr_y,viewsin);
  522.     
  523.     tz = gxt-gyt; 
  524.  
  525.     // thing is behind view plane?
  526.     if (tz < MINZ)
  527.     return;
  528.     
  529.     xscale = FixedDiv(projection, tz);
  530.     
  531.     gxt = -FixedMul(tr_x,viewsin); 
  532.     gyt = FixedMul(tr_y,viewcos); 
  533.     tx = -(gyt+gxt); 
  534.  
  535.     // too far off the side?
  536.     if (iabs(tx)>(tz<<2))
  537.     return;
  538.     
  539.     // decide which patch to use for sprite relative to player
  540. #ifdef RANGECHECK
  541.     if ((unsigned)thing->sprite >= numsprites)
  542.     I_Error ("R_ProjectSprite: invalid sprite number %i ",
  543.          thing->sprite);
  544. #endif
  545.     sprdef = &sprites[thing->sprite];
  546. #ifdef RANGECHECK
  547.     if ( (thing->frame&FF_FRAMEMASK) >= sprdef->numframes )
  548.     I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  549.          thing->sprite, thing->frame);
  550. #endif
  551.     sprframe = &sprdef->spriteframes[ thing->frame & FF_FRAMEMASK];
  552.  
  553.     if (sprframe->rotate)
  554.     {
  555.     // choose a different rotation based on player view
  556.     ang = R_PointToAngle (thing->x, thing->y);
  557.     rot = (ang-thing->angle+(unsigned)(ANG45/2)*9)>>29;
  558.     lump = sprframe->lump[rot];
  559.     flip = (boolean)sprframe->flip[rot];
  560.     }
  561.     else
  562.     {
  563.     // use single rotation for all views
  564.     lump = sprframe->lump[0];
  565.     flip = (boolean)sprframe->flip[0];
  566.     }
  567.     
  568.     // calculate edges of the shape
  569.     tx -= spriteoffset[lump];    
  570.     x1 = (centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS;
  571.  
  572.     // off the right side?
  573.     if (x1 > viewwidth)
  574.     return;
  575.     
  576.     tx +=  spritewidth[lump];
  577.     x2 = ((centerxfrac + FixedMul (tx,xscale) ) >>FRACBITS) - 1;
  578.  
  579.     // off the left side
  580.     if (x2 < 0)
  581.     return;
  582.     
  583.     // store information in a vissprite
  584.     vis = R_NewVisSprite ();
  585.     vis->mobjflags = thing->flags;
  586.     vis->scale = xscale<<detailshift;
  587.     vis->gx = thing->x;
  588.     vis->gy = thing->y;
  589.     vis->gz = thing->z;
  590.     vis->gzt = thing->z + spritetopoffset[lump];
  591.     vis->texturemid = vis->gzt - viewz;
  592.     vis->x1 = x1 < 0 ? 0 : x1;
  593.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;    
  594.     iscale = FixedDiv (FRACUNIT, xscale);
  595.  
  596.     if (flip)
  597.     {
  598.     vis->startfrac = spritewidth[lump]-1;
  599.     vis->xiscale = -iscale;
  600.     }
  601.     else
  602.     {
  603.     vis->startfrac = 0;
  604.     vis->xiscale = iscale;
  605.     }
  606.  
  607.     if (vis->x1 > x1)
  608.     vis->startfrac += vis->xiscale*(vis->x1-x1);
  609.     vis->patch = lump;
  610.     
  611.     // get light level
  612.     if (thing->flags & MF_SHADOW)
  613.     {
  614.     // shadow draw
  615.     vis->colormap = NULL;
  616.     }
  617.     else if (fixedcolormap)
  618.     {
  619.     // fixed map
  620.     vis->colormap = fixedcolormap;
  621.     }
  622.     else if (thing->frame & FF_FULLBRIGHT)
  623.     {
  624.     // full bright
  625.     vis->colormap = colormaps;
  626.     }
  627.     
  628.     else
  629.     {
  630.     // diminished light
  631.     index = xscale>>(LIGHTSCALESHIFT-detailshift);
  632.  
  633.     if (index >= MAXLIGHTSCALE) 
  634.         index = MAXLIGHTSCALE-1;
  635.  
  636.     vis->colormap = spritelights[index];
  637.     }    
  638. }
  639.  
  640.  
  641.  
  642.  
  643. #ifndef AMIGA
  644. //
  645. // R_AddSprites
  646. // During BSP traversal, this adds sprites by sector.
  647. //
  648. void R_AddSprites (sector_t* sec)
  649. {
  650.     mobj_t*        thing;
  651.     int            lightnum;
  652.  
  653.     // BSP is traversed by subsector.
  654.     // A sector might have been split into several
  655.     //  subsectors during BSP building.
  656.     // Thus we check whether its already added.
  657.     if (sec->validcount == validcount)
  658.     return;        
  659.  
  660.     // Well, now it will be done.
  661.     sec->validcount = validcount;
  662.     
  663.     lightnum = (sec->lightlevel >> LIGHTSEGSHIFT)+extralight;
  664.  
  665.     if (lightnum < 0)        
  666.     spritelights = scalelight[0];
  667.     else if (lightnum >= LIGHTLEVELS)
  668.     spritelights = scalelight[LIGHTLEVELS-1];
  669.     else
  670.     spritelights = scalelight[lightnum];
  671.  
  672.     // Handle all things in sector.
  673.     for (thing = sec->thinglist ; thing ; thing = thing->snext)
  674.     R_ProjectSprite (thing);
  675. }
  676. #endif
  677.  
  678.  
  679. //
  680. // R_DrawPSprite
  681. //
  682. void R_DrawPSprite (pspdef_t* psp)
  683. {
  684.     fixed_t        tx;
  685.     int            x1;
  686.     int            x2;
  687.     spritedef_t*    sprdef;
  688.     spriteframe_t*    sprframe;
  689.     int            lump;
  690.     boolean        flip;
  691.     vissprite_t*    vis;
  692.     vissprite_t        avis;
  693.     
  694.     // decide which patch to use
  695. #ifdef RANGECHECK
  696.     if ( (unsigned)psp->state->sprite >= numsprites)
  697.     I_Error ("R_ProjectSprite: invalid sprite number %i ",
  698.          psp->state->sprite);
  699. #endif
  700.     sprdef = &sprites[psp->state->sprite];
  701. #ifdef RANGECHECK
  702.     if ( (psp->state->frame & FF_FRAMEMASK)  >= sprdef->numframes)
  703.     I_Error ("R_ProjectSprite: invalid sprite frame %i : %i ",
  704.          psp->state->sprite, psp->state->frame);
  705. #endif
  706.     sprframe = &sprdef->spriteframes[ psp->state->frame & FF_FRAMEMASK ];
  707.  
  708.     lump = sprframe->lump[0];
  709.     flip = (boolean)sprframe->flip[0];
  710.     
  711.     // calculate edges of the shape
  712.     tx = psp->sx-160*FRACUNIT;
  713.     
  714.     tx -= spriteoffset[lump];    
  715.     x1 = (centerxfrac + FixedMul (tx,pspritescale) ) >>FRACBITS;
  716.  
  717.     // off the right side
  718.     if (x1 > viewwidth)
  719.     return;        
  720.  
  721.     tx +=  spritewidth[lump];
  722.     x2 = ((centerxfrac + FixedMul (tx, pspritescale) ) >>FRACBITS) - 1;
  723.  
  724.     // off the left side
  725.     if (x2 < 0)
  726.     return;
  727.     
  728.     // store information in a vissprite
  729.     vis = &avis;
  730.     vis->mobjflags = 0;
  731.     vis->texturemid = (BASEYCENTER<<FRACBITS)+FRACUNIT/2-(psp->sy-spritetopoffset[lump]);
  732.     vis->x1 = x1 < 0 ? 0 : x1;
  733.     vis->x2 = x2 >= viewwidth ? viewwidth-1 : x2;    
  734.     vis->scale = pspritescale<<detailshift;
  735.     
  736.     if (flip)
  737.     {
  738.     vis->xiscale = -pspriteiscale;
  739.     vis->startfrac = spritewidth[lump]-1;
  740.     }
  741.     else
  742.     {
  743.     vis->xiscale = pspriteiscale;
  744.     vis->startfrac = 0;
  745.     }
  746.     
  747.     if (vis->x1 > x1)
  748.     vis->startfrac += vis->xiscale*(vis->x1-x1);
  749.  
  750.     vis->patch = lump;
  751.  
  752.     if (viewplayer->powers[pw_invisibility] > 4*32
  753.     || viewplayer->powers[pw_invisibility] & 8)
  754.     {
  755.     // shadow draw
  756.     vis->colormap = NULL;
  757.     }
  758.     else if (fixedcolormap)
  759.     {
  760.     // fixed color
  761.     vis->colormap = fixedcolormap;
  762.     }
  763.     else if (psp->state->frame & FF_FULLBRIGHT)
  764.     {
  765.     // full bright
  766.     vis->colormap = colormaps;
  767.     }
  768.     else
  769.     {
  770.     // local light
  771.     vis->colormap = spritelights[MAXLIGHTSCALE-1];
  772.     }
  773.     
  774. #ifdef AMIGA
  775.     R_DrawVisSprite (vis);
  776. #else
  777.     R_DrawVisSprite (vis, vis->x1, vis->x2);
  778. #endif
  779. }
  780.  
  781.  
  782.  
  783. //
  784. // R_DrawPlayerSprites
  785. //
  786. void R_DrawPlayerSprites (void)
  787. {
  788.     int        i;
  789.     int        lightnum;
  790.     pspdef_t*    psp;
  791.     
  792.     // get light level
  793.     lightnum =
  794.     (viewplayer->mo->subsector->sector->lightlevel >> LIGHTSEGSHIFT) 
  795.     +extralight;
  796.  
  797.     if (lightnum < 0)        
  798.     spritelights = scalelight[0];
  799.     else if (lightnum >= LIGHTLEVELS)
  800.     spritelights = scalelight[LIGHTLEVELS-1];
  801.     else
  802.     spritelights = scalelight[lightnum];
  803.     
  804.     // clip to screen bounds
  805.     mfloorclip = screenheightarray;
  806.     mceilingclip = negonearray;
  807.     
  808.     // add all active psprites
  809.     for (i=0, psp=viewplayer->psprites;
  810.      i<NUMPSPRITES;
  811.      i++,psp++)
  812.     {
  813.     if (psp->state)
  814.         R_DrawPSprite (psp);
  815.     }
  816. }
  817.  
  818.  
  819. vissprite_t    vsprsortedhead;
  820.  
  821. #ifndef AMIGA
  822. //
  823. // R_SortVisSprites
  824. //
  825. void R_SortVisSprites (void)
  826. {
  827.     int            i;
  828.     int            count;
  829.     vissprite_t*    ds;
  830.     vissprite_t*    best;
  831.     vissprite_t        unsorted;
  832.     fixed_t        bestscale;
  833.  
  834.     count = vissprite_p - vissprites;
  835.     
  836.     unsorted.next = unsorted.prev = &unsorted;
  837.  
  838.     if (!count)
  839.     return;
  840.         
  841.     for (ds=vissprites ; ds<vissprite_p ; ds++)
  842.     {
  843.     ds->next = ds+1;
  844.     ds->prev = ds-1;
  845.     }
  846.     
  847.     vissprites[0].prev = &unsorted;
  848.     unsorted.next = &vissprites[0];
  849.     (vissprite_p-1)->next = &unsorted;
  850.     unsorted.prev = vissprite_p-1;
  851.     
  852.     // pull the vissprites out by scale
  853.     //best = 0;        // shut up the compiler warning
  854.     vsprsortedhead.next = vsprsortedhead.prev = &vsprsortedhead;
  855.     for (i=0 ; i<count ; i++)
  856.     {
  857.     bestscale = MAXINT;
  858.     for (ds=unsorted.next ; ds!= &unsorted ; ds=ds->next)
  859.     {
  860.         if (ds->scale < bestscale)
  861.         {
  862.         bestscale = ds->scale;
  863.         best = ds;
  864.         }
  865.     }
  866.     best->next->prev = best->prev;
  867.     best->prev->next = best->next;
  868.     best->next = &vsprsortedhead;
  869.     best->prev = vsprsortedhead.prev;
  870.     vsprsortedhead.prev->next = best;
  871.     vsprsortedhead.prev = best;
  872.     }
  873. }
  874. #endif
  875.  
  876.  
  877.  
  878. #ifndef AMIGA
  879. //
  880. // R_DrawSprite
  881. //
  882. void R_DrawSprite (vissprite_t* spr)
  883. {
  884.     drawseg_t*        ds;
  885. //    short        clipbot[SCREENWIDTH];
  886. //    short        cliptop[SCREENWIDTH];
  887.     static short    clipbot[MAXSCREENWIDTH];
  888.     static short    cliptop[MAXSCREENWIDTH];
  889.     int            x;
  890.     int            r1;
  891.     int            r2;
  892.     fixed_t        scale;
  893.     fixed_t        lowscale;
  894.     int            silhouette;
  895.  
  896. //    clipbot = I_malloc (SCREENWIDTH * sizeof(short));
  897. //    cliptop = I_malloc (SCREENWIDTH * sizeof(short));
  898.  
  899.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  900.     clipbot[x] = cliptop[x] = -2;
  901.     
  902.     // Scan drawsegs from end to start for obscuring segs.
  903.     // The first drawseg that has a greater scale
  904.     //  is the clip seg.
  905.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  906.     {
  907.     // determine if the drawseg obscures the sprite
  908.     if (ds->x1 > spr->x2
  909.         || ds->x2 < spr->x1
  910.         || (!ds->silhouette
  911.         && !ds->maskedtexturecol) )
  912.     {
  913.         // does not cover sprite
  914.         continue;
  915.     }
  916.             
  917.     r1 = ds->x1 < spr->x1 ? spr->x1 : ds->x1;
  918.     r2 = ds->x2 > spr->x2 ? spr->x2 : ds->x2;
  919.  
  920.     if (ds->scale1 > ds->scale2)
  921.     {
  922.         lowscale = ds->scale2;
  923.         scale = ds->scale1;
  924.     }
  925.     else
  926.     {
  927.         lowscale = ds->scale1;
  928.         scale = ds->scale2;
  929.     }
  930.         
  931.     if (scale < spr->scale
  932.         || ( lowscale < spr->scale
  933.          && !R_PointOnSegSide (spr->gx, spr->gy, ds->curline) ) )
  934.     {
  935.         // masked mid texture?
  936.         if (ds->maskedtexturecol)    
  937.         R_RenderMaskedSegRange (ds, r1, r2);
  938.         // seg is behind sprite
  939.         continue;            
  940.     }
  941.  
  942.     
  943.     // clip this piece of the sprite
  944.     silhouette = ds->silhouette;
  945.     
  946.     if (spr->gz >= ds->bsilheight)
  947.         silhouette &= ~SIL_BOTTOM;
  948.  
  949.     if (spr->gzt <= ds->tsilheight)
  950.         silhouette &= ~SIL_TOP;
  951.             
  952.     if (silhouette == 1)
  953.     {
  954.         // bottom sil
  955.         for (x=r1 ; x<=r2 ; x++)
  956.         if (clipbot[x] == -2)
  957.             clipbot[x] = ds->sprbottomclip[x];
  958.     }
  959.     else if (silhouette == 2)
  960.     {
  961.         // top sil
  962.         for (x=r1 ; x<=r2 ; x++)
  963.         if (cliptop[x] == -2)
  964.             cliptop[x] = ds->sprtopclip[x];
  965.     }
  966.     else if (silhouette == 3)
  967.     {
  968.         // both
  969.         for (x=r1 ; x<=r2 ; x++)
  970.         {
  971.         if (clipbot[x] == -2)
  972.             clipbot[x] = ds->sprbottomclip[x];
  973.         if (cliptop[x] == -2)
  974.             cliptop[x] = ds->sprtopclip[x];
  975.         }
  976.     }
  977.         
  978.     }
  979.     
  980.     // all clipping has been performed, so draw the sprite
  981.  
  982.     // check for unclipped columns
  983.     for (x = spr->x1 ; x<=spr->x2 ; x++)
  984.     {
  985.     if (clipbot[x] == -2)        
  986.         clipbot[x] = viewheight;
  987.  
  988.     if (cliptop[x] == -2)
  989.         cliptop[x] = -1;
  990.     }
  991.         
  992.     mfloorclip = clipbot;
  993.     mceilingclip = cliptop;
  994.     R_DrawVisSprite (spr, spr->x1, spr->x2);
  995.  
  996. //    free (clipbot);
  997. //    free (cliptop);
  998. }
  999. #endif
  1000.  
  1001.  
  1002.  
  1003.  
  1004. #ifndef AMIGA
  1005. //
  1006. // R_DrawMasked
  1007. //
  1008. void R_DrawMasked (void)
  1009. {
  1010.     vissprite_t*    spr;
  1011.     drawseg_t*        ds;
  1012.     
  1013.     R_SortVisSprites ();
  1014.  
  1015.     if (vissprite_p > vissprites)
  1016.     {
  1017.     // draw all vissprites back to front
  1018.     for (spr = vsprsortedhead.next ;
  1019.          spr != &vsprsortedhead ;
  1020.          spr=spr->next)
  1021.     {
  1022.         
  1023.         R_DrawSprite (spr);
  1024.     }
  1025.     }
  1026.     
  1027.     // render any remaining masked mid textures
  1028.     for (ds=ds_p-1 ; ds >= drawsegs ; ds--)
  1029.     if (ds->maskedtexturecol)
  1030.         R_RenderMaskedSegRange (ds, ds->x1, ds->x2);
  1031.     
  1032.     // draw the psprites on top of everything
  1033.     //  but does not draw on side views
  1034.     if (!viewangleoffset)        
  1035.     R_DrawPlayerSprites ();
  1036. }
  1037. #endif
  1038.  
  1039.